home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / MAIL.XPI / bin / chrome / messenger.jar / content / messenger / AccountWizard.js < prev    next >
Encoding:
JavaScript  |  2005-03-23  |  36.0 KB  |  1,028 lines
  1. /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  * ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is Mozilla Communicator client code, released
  16.  * March 31, 1998.
  17.  *
  18.  * The Initial Developer of the Original Code is
  19.  * Netscape Communications Corporation.
  20.  * Portions created by the Initial Developer are Copyright (C) 1998-1999
  21.  * the Initial Developer. All Rights Reserved.
  22.  *
  23.  * Contributor(s):
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the MPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the MPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. /* the okCallback is used for sending a callback for the parent window */
  40. var okCallback = null;
  41. /* The account wizard creates new accounts */
  42.  
  43. /*
  44.   data flow into the account wizard like this:
  45.  
  46.   For new accounts:
  47.   * pageData -> Array -> createAccount -> finishAccount
  48.   
  49.   For accounts coming from the ISP setup:
  50.   * RDF  -> Array -> pageData -> Array -> createAccount -> finishAccount
  51.   
  52.   for "unfinished accounts" 
  53.   * account -> Array -> pageData -> Array -> finishAccount
  54.   
  55.   Where:
  56.   pageData - the actual pages coming out of the Widget State Manager
  57.   RDF      - the ISP datasource
  58.   Array    - associative array of attributes, that very closely
  59.              resembles the nsIMsgAccount/nsIMsgIncomingServer/nsIMsgIdentity
  60.              structure
  61.   createAccount() - creates an account from the above Array
  62.   finishAccount() - fills an existing account with data from the above Array 
  63.  
  64. */
  65.  
  66. /* 
  67.    the account wizard path is something like:
  68.    
  69.    accounttype -> identity -> server -> login -> accname -> done
  70.                              \-> newsserver ----/
  71.  
  72.    where the accounttype determines which path to take
  73.    (server vs. newsserver)
  74. */
  75.  
  76. var contentWindow;
  77.  
  78. var gPageData;
  79. var smtpService = Components.classes["@mozilla.org/messengercompose/smtp;1"].getService(Components.interfaces.nsISmtpService);
  80. var am = Components.classes["@mozilla.org/messenger/account-manager;1"].getService(Components.interfaces.nsIMsgAccountManager);
  81. var gPrefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
  82. var gMailSession = Components.classes["@mozilla.org/messenger/services/session;1"].getService(Components.interfaces.nsIMsgMailSession);
  83. var accounts = am.accounts;
  84.  
  85. //accountCount indicates presence or absense of accounts
  86. var accountCount = accounts.Count();
  87.  
  88. var nsIMsgIdentity = Components.interfaces.nsIMsgIdentity;
  89. var nsIMsgIncomingServer = Components.interfaces.nsIMsgIncomingServer;
  90. var gPrefsBundle, gMessengerBundle;
  91. var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService();
  92. promptService = promptService.QueryInterface(Components.interfaces.nsIPromptService);
  93.  
  94. // the current nsIMsgAccount
  95. var gCurrentAccount;
  96.  
  97. // default account
  98. var gDefaultAccount;
  99.  
  100. // the current associative array that
  101. // will eventually be dumped into the account
  102. var gCurrentAccountData;
  103.  
  104. // default picker mode for copies and folders
  105. const gDefaultSpecialFolderPickerMode = "0";
  106.  
  107. // event handlers
  108. function onAccountWizardLoad() {
  109.     gPrefsBundle = document.getElementById("bundle_prefs");
  110.     gMessengerBundle = document.getElementById("bundle_messenger");
  111.  
  112.     if ("testingIspServices" in this) {
  113.       if ("SetCustomizedWizardDimensions" in this && testingIspServices()) {
  114.         SetCustomizedWizardDimensions();
  115.       }
  116.     }
  117.  
  118.     /* We are checking here for the callback argument */
  119.     if (window.arguments && window.arguments[0]) {
  120.         if(window.arguments[0].okCallback ) 
  121.         {
  122.             //dump("There is okCallback");
  123.             top.okCallback = window.arguments[0].okCallback;
  124.         }
  125.     }
  126.  
  127.     checkForInvalidAccounts();
  128.  
  129.     try {
  130.         gDefaultAccount = am.defaultAccount;
  131.     }
  132.     catch (ex) {
  133.         // no default account, this is expected the first time you launch mail
  134.         // on a new profile
  135.         gDefaultAccount = null;
  136.     }
  137. }
  138.  
  139. function onCancel() 
  140. {
  141.   if ("ActivationOnCancel" in this && ActivationOnCancel())
  142.     return false;
  143.   var firstInvalidAccount = getFirstInvalidAccount();
  144.   var closeWizard = true;
  145.  
  146.   // if the user cancels the the wizard when it pops up because of 
  147.   // an invalid account (example, a webmail account that activation started)
  148.   // we just force create it by setting some values and calling the FinishAccount()
  149.   // see bug #47521 for the full discussion
  150.   if (firstInvalidAccount) {
  151.     var pageData = GetPageData();
  152.     // set the fullName if it doesn't exist
  153.     if (!pageData.identity.fullName || !pageData.identity.fullName.value) {
  154.       setPageData(pageData, "identity", "fullName", "");
  155.     }
  156.  
  157.     // set the email if it doesn't exist
  158.     if (!pageData.identity.email || !pageData.identity.email.value) {
  159.       setPageData(pageData, "identity", "email", "user@domain.invalid");
  160.     }
  161.  
  162.     // call FinishAccount() and not onFinish(), since the "finish"
  163.     // button may be disabled
  164.     FinishAccount();
  165.   }
  166.   else {
  167.     // since this is not an invalid account
  168.     // really cancel if the user hits the "cancel" button
  169.     if (accountCount < 1) {
  170.       var confirmMsg = gPrefsBundle.getString("cancelWizard");
  171.       var confirmTitle = gPrefsBundle.getString("accountWizard");
  172.       var result = promptService.confirmEx(window, confirmTitle, confirmMsg,
  173.         (promptService.BUTTON_TITLE_IS_STRING*promptService.BUTTON_POS_0)+
  174.         (promptService.BUTTON_TITLE_IS_STRING*promptService.BUTTON_POS_1),
  175.         gPrefsBundle.getString('WizardExit'),
  176.         gPrefsBundle.getString('WizardContinue'), 
  177.         null, null, {value:0});
  178.  
  179.       if (result == 1)
  180.         closeWizard = false;
  181.     }
  182.  
  183.     if(top.okCallback && closeWizard) {
  184.       var state = false;
  185.       top.okCallback(state);
  186.     }
  187.   }
  188.   return closeWizard;
  189. }
  190.  
  191. function FinishAccount() 
  192. {
  193.   try {
  194.     var pageData = GetPageData();
  195.  
  196.     var accountData= gCurrentAccountData;
  197.     
  198.     if (!accountData)
  199.     {
  200.       accountData = new Object;
  201.       // Time to set the smtpRequiresUsername attribute
  202.       if (!serverIsNntp(pageData))
  203.         accountData.smtpRequiresUsername = true;
  204.     }
  205.     
  206.     // we may need local folders before account is "Finished"
  207.     // if it's a pop3 account which defers to Local Folders.
  208.     verifyLocalFoldersAccount();
  209.  
  210.     PageDataToAccountData(pageData, accountData);
  211.  
  212.     FixupAccountDataForIsp(accountData);
  213.     
  214.     // we might be simply finishing another account
  215.     if (!gCurrentAccount)
  216.         gCurrentAccount = createAccount(accountData);
  217.  
  218.     // transfer all attributes from the accountdata
  219.     finishAccount(gCurrentAccount, accountData);
  220.     
  221.     setupCopiesAndFoldersServer(gCurrentAccount, getCurrentServerIsDeferred(pageData));
  222.  
  223.     if (!serverIsNntp(pageData))
  224.         EnableCheckMailAtStartUpIfNeeded(gCurrentAccount);
  225.  
  226.     if (!document.getElementById("downloadMsgs").hidden) {
  227.       if (document.getElementById("downloadMsgs").checked) {
  228.         window.opener.gNewAccountToLoad = gCurrentAccount; // load messages for new POP account
  229.       }
  230.       else if (gCurrentAccount == am.defaultAccount) {
  231.         // stop check for msgs when this is first account created from new profile
  232.         window.opener.gLoadStartFolder = false;
  233.       }
  234.     }
  235.  
  236.     // in case we crash, force us a save of the prefs file NOW
  237.     try {
  238.       am.saveAccountInfo();
  239.     } 
  240.     catch (ex) {
  241.       dump("Error saving account info: " + ex + "\n");
  242.     }
  243.     window.close();
  244.     if(top.okCallback)
  245.     {
  246.         var state = true;
  247.         //dump("finish callback");
  248.         top.okCallback(state);
  249.     }
  250. }
  251.   catch(ex) {
  252.     dump("FinishAccount failed, " + ex +"\n");
  253.   }
  254. }
  255.  
  256. // prepopulate pageData with stuff from accountData
  257. // use: to prepopulate the wizard with account information
  258. function AccountDataToPageData(accountData, pageData)
  259. {
  260.     if (!accountData) {
  261.         dump("null account data! clearing..\n");
  262.         // handle null accountData as if it were an empty object
  263.         // so that we clear-out any old pagedata from a
  264.         // previous accountdata. The trick is that
  265.         // with an empty object, accountData.identity.slot is undefined,
  266.         // so this will clear out the prefill data in setPageData
  267.         
  268.         accountData = new Object;
  269.         accountData.incomingServer = new Object;
  270.         accountData.identity = new Object;
  271.         accountData.smtp = new Object;
  272.     }
  273.     
  274.     var server = accountData.incomingServer;
  275.  
  276.     if (server.type == undefined) {
  277.         // clear out the old server data
  278.         //setPageData(pageData, "accounttype", "mailaccount", undefined);
  279.         //        setPageData(pageData, "accounttype", "newsaccount", undefined);
  280.         setPageData(pageData, "server", "servertype", undefined);
  281.         setPageData(pageData, "server", "hostname", undefined);
  282.         
  283.     } else {
  284.         
  285.         if (server.type == "nntp") {
  286.             setPageData(pageData, "accounttype", "newsaccount", true);
  287.             setPageData(pageData, "accounttype", "mailaccount", false);
  288.             setPageData(pageData, "newsserver", "hostname", server.hostName);
  289.         }
  290.         
  291.         else {
  292.             setPageData(pageData, "accounttype", "mailaccount", true);
  293.             setPageData(pageData, "accounttype", "newsaccount", false);
  294.             setPageData(pageData, "server", "servertype", server.type);
  295.             setPageData(pageData, "server", "hostname", server.hostName);
  296.         }
  297.     }
  298.     
  299.     setPageData(pageData, "login", "username", server.username);
  300.     setPageData(pageData, "login", "password", server.password);
  301.     setPageData(pageData, "login", "rememberPassword", server.rememberPassword);
  302.     setPageData(pageData, "accname", "prettyName", server.prettyName);
  303.     
  304.     var identity;
  305.     
  306.     if (accountData.identity) {
  307.         dump("This is an accountdata\n");
  308.         identity = accountData.identity;
  309.     }
  310.     else if (accountData.identities) {
  311.         identity = accountData.identities.QueryElementAt(0, Components.interfaces.nsIMsgIdentity);
  312.         dump("this is an account, id= " + identity + "\n");
  313.     } 
  314.  
  315.     setPageData(pageData, "identity", "email", identity.email);
  316.     setPageData(pageData, "identity", "fullName", identity.fullName);
  317.  
  318.     var smtp;
  319.     
  320.     if (accountData.smtp) {
  321.         smtp = accountData.smtp;
  322.         setPageData(pageData, "server", "smtphostname", smtp.hostname);
  323.         setPageData(pageData, "login", "smtpusername", smtp.username);
  324.     }
  325. }
  326.  
  327. // take data from each page of pageData and dump it into accountData
  328. // use: to put results of wizard into a account-oriented object
  329. function PageDataToAccountData(pageData, accountData)
  330. {
  331.     if (!accountData.identity)
  332.         accountData.identity = new Object;
  333.     if (!accountData.incomingServer)
  334.         accountData.incomingServer = new Object;
  335.     if (!accountData.smtp)
  336.         accountData.smtp = new Object;
  337.     if (!accountData.pop3)
  338.         accountData.pop3 = new Object;
  339.     
  340.     var identity = accountData.identity;
  341.     var server = accountData.incomingServer;
  342.     var smtp = accountData.smtp;
  343.  
  344.     if (pageData.identity.email)
  345.         identity.email = pageData.identity.email.value;
  346.     if (pageData.identity.fullName)
  347.         identity.fullName = pageData.identity.fullName.value;
  348.  
  349.     server.type = getCurrentServerType(pageData);
  350.     server.hostName = getCurrentHostname(pageData);
  351.     if (getCurrentServerIsDeferred(pageData))
  352.     {
  353.       try
  354.       {
  355.         var accountManager = Components.classes["@mozilla.org/messenger/account-manager;1"].getService(Components.interfaces.nsIMsgAccountManager);
  356.         var localFoldersServer = accountManager.localFoldersServer;
  357.         var localFoldersAccount = accountManager.FindAccountForServer(localFoldersServer);
  358.         accountData.pop3.deferredToAccount = localFoldersAccount.key;
  359.         accountData.pop3.deferGetNewMail = true;
  360.         server["ServerType-pop3"] = accountData.pop3;
  361.       }
  362.       catch (ex) {dump ("exception setting up deferred account" + ex);}
  363.     }
  364.     if (serverIsNntp(pageData)) {
  365.         // this stuff probably not relevant
  366.         dump("not setting username/password/rememberpassword/etc\n");
  367.     } else {
  368.         if (pageData.login) {
  369.             if (pageData.login.username)
  370.                 server.username = pageData.login.username.value;
  371.             if (pageData.login.password)
  372.                 server.password = pageData.login.password.value;
  373.             if (pageData.login.rememberPassword)
  374.                 server.rememberPassword = pageData.login.rememberPassword.value;
  375.             if (pageData.login.smtpusername)
  376.                 smtp.username = pageData.login.smtpusername.value;
  377.         }
  378.  
  379.         dump("pageData.server = " + pageData.server + "\n");
  380.         if (pageData.server) {
  381.             dump("pageData.server.smtphostname.value = " + pageData.server.smtphostname + "\n");
  382.             if (pageData.server.smtphostname &&
  383.                 pageData.server.smtphostname.value)
  384.                 smtp.hostname = pageData.server.smtphostname.value;
  385.         }
  386.         if (pageData.identity.smtpServerKey)
  387.             identity.smtpServerKey = pageData.identity.smtpServerKey.value;
  388.     }
  389.  
  390.     if (pageData.accname) {
  391.         if (pageData.accname.prettyName)
  392.             server.prettyName = pageData.accname.prettyName.value;
  393.     }
  394.  
  395. }
  396.  
  397. // given an accountData structure, create an account
  398. // (but don't fill in any fields, that's for finishAccount()
  399. function createAccount(accountData)
  400. {
  401.     var server = accountData.incomingServer;
  402.     
  403.     // for news, username is always null
  404.     var username = (server.type == "nntp") ? null : server.username;
  405.  
  406.     dump("am.createIncomingServer(" + username + "," +
  407.                                       server.hostName + "," +
  408.                                       server.type + ")\n");
  409.     
  410.     var server = am.createIncomingServer(username,
  411.                                          server.hostName,
  412.                                          server.type);
  413.  
  414.     dump("am.createAccount()\n");
  415.     var account = am.createAccount();
  416.     
  417.     if (accountData.identity.email) // only create an identity for this account if we really have one (use the email address as a check)
  418.     {
  419.         dump("am.createIdentity()\n");
  420.         var identity = am.createIdentity();
  421.     
  422.         /* new nntp identities should use plain text by default
  423.          * we want that GNKSA (The Good Net-Keeping Seal of Approval) */
  424.         if (server.type == "nntp") {
  425.                 identity.composeHtml = false;
  426.         }
  427.  
  428.         account.addIdentity(identity);
  429.     }
  430.  
  431.     // we mark the server as invalid so that the account manager won't
  432.     // tell RDF about the new server - it's not quite finished getting
  433.     // set up yet, in particular, the deferred storage pref hasn't been set.
  434.     server.valid = false;
  435.     account.incomingServer = server;
  436.     server.valid = true;
  437.     return account;
  438. }
  439.  
  440. // given an accountData structure, copy the data into the
  441. // given account, incoming server, and so forth
  442. function finishAccount(account, accountData) 
  443. {
  444.     if (accountData.incomingServer) {
  445.  
  446.         var destServer = account.incomingServer;
  447.         var srcServer = accountData.incomingServer;
  448.         copyObjectToInterface(destServer, srcServer);
  449.  
  450.         // see if there are any protocol-specific attributes
  451.         // if so, we use the type to get the IID, QueryInterface
  452.         // as appropriate, then copy the data over
  453.         dump("srcServer.ServerType-" + srcServer.type + " = " +
  454.              srcServer["ServerType-" + srcServer.type] + "\n");
  455.         if (srcServer["ServerType-" + srcServer.type]) {
  456.             // handle server-specific stuff
  457.             var IID = getInterfaceForType(srcServer.type);
  458.             if (IID) {
  459.                 destProtocolServer = destServer.QueryInterface(IID);
  460.                 srcProtocolServer = srcServer["ServerType-" + srcServer.type];
  461.  
  462.                 dump("Copying over " + srcServer.type + "-specific data\n");
  463.                 copyObjectToInterface(destProtocolServer, srcProtocolServer);
  464.             }
  465.         }
  466.         account.incomingServer.valid=true;
  467.         // hack to cause an account loaded notification now the server is valid
  468.         account.incomingServer = account.incomingServer;
  469.     }
  470.  
  471.     // copy identity info
  472.     var destIdentity = account.identities.Count() ? account.identities.QueryElementAt(0, nsIMsgIdentity) : null;
  473.  
  474.     if (destIdentity) // does this account have an identity? 
  475.     {   
  476.         if (accountData.identity && accountData.identity.email) {
  477.             dump('trying to write out an identity: ' + destIdentity + '\n');
  478.  
  479.             // fixup the email address if we have a default domain
  480.             var emailArray = accountData.identity.email.split('@');
  481.             if (emailArray.length < 2 && accountData.domain) {
  482.                 accountData.identity.email += '@' + accountData.domain;
  483.             }
  484.  
  485.             copyObjectToInterface(destIdentity,
  486.                                   accountData.identity);
  487.             destIdentity.valid=true;
  488.         }
  489.  
  490.         /**
  491.          * If signature file need to be set, get the path to the signature file.
  492.          * Signature files, if exist, are placed under default location. Get
  493.          * default files location for messenger using directory service. Signature 
  494.          * file name should be extracted from the account data to build the complete
  495.          * path for signature file. Once the path is built, set the identity's signature pref.
  496.          */
  497.         if (destIdentity.attachSignature)
  498.         {
  499.             var sigFileName = accountData.signatureFileName;
  500.       
  501.             var sigFile = gMailSession.getDataFilesDir("messenger");
  502.             sigFile.append(sigFileName);
  503.             destIdentity.signature = sigFile;
  504.         }
  505.  
  506.         // don't try to create an smtp server if we already have one.
  507.         if (!destIdentity.smtpServerKey)
  508.         {
  509.             var smtpServer;
  510.         
  511.             /**
  512.              * Create a new smtp server if needed. If smtpCreateNewServer pref
  513.              * is set then createSmtpServer routine() will create one. Otherwise,
  514.              * default server is returned which is also set to create a new smtp server
  515.              * (via GetDefaultServer()) if no default server is found.
  516.              */
  517.             if (accountData.smtp.hostname != null)
  518.               smtpServer = smtpService.createSmtpServer();
  519.             else
  520.               smtpServer = smtpService.defaultServer;
  521.  
  522.             // may not have a smtp server, see bug #138076
  523.             if (smtpServer) {
  524.               dump("Copying smtpServer (" + smtpServer + ") to accountData\n");
  525.               //set the smtp server to be the default only if it is not a redirectorType
  526.               if (accountData.smtp.redirectorType == null) 
  527.               {
  528.                 if ((smtpService.defaultServer.hostname == null) || (smtpService.defaultServer.redirectorType != null))
  529.                   smtpService.defaultServer = smtpServer;
  530.               }
  531.  
  532.               copyObjectToInterface(smtpServer, accountData.smtp);
  533.  
  534.               // refer bug#141314
  535.               // since we clone the default smtpserver with the new account's username
  536.               // force every account to use the smtp server that was created or assigned to it in the
  537.               // case of isps using rdf files
  538.               try{
  539.                 destIdentity.smtpServerKey = smtpServer.key;
  540.               }
  541.               catch(ex)
  542.               {
  543.                 dump("There is no smtp server assigned to this account: Exception= "+ex+"\n");
  544.               }
  545.             }
  546.          }
  547.      } // if the account has an identity...
  548.  
  549.      if (this.FinishAccountHook != undefined) {
  550.          FinishAccountHook(accountData.domain);
  551.      }
  552. }
  553.  
  554. // copy over all attributes from dest into src that already exist in src
  555. // the assumption is that src is an XPConnect interface full of attributes
  556. function copyObjectToInterface(dest, src) {
  557.     if (!dest) return;
  558.     if (!src) return;
  559.  
  560.     var i;
  561.     for (i in src) {
  562.         try {
  563.             if (dest[i] != src[i])
  564.                 dest[i] = src[i];
  565.         }
  566.         catch (ex) {
  567.             dump("Error copying the " +
  568.                  i + " attribute: " + ex + "\n");
  569.             dump("[This is ok if this is a ServerType-* attribute, or if this is a readonly attribute (like receiptHeaderType)]\n");
  570.         }
  571.     }
  572. }
  573.  
  574. // check if there already is a "Local Folders"
  575. // if not, create it.
  576. function verifyLocalFoldersAccount() 
  577. {
  578.   dump ("verifying local folders account\n");
  579.   var localMailServer = null;
  580.   try {
  581.     localMailServer = am.localFoldersServer;
  582.   }
  583.   catch (ex) {
  584.          // dump("exception in findserver: " + ex + "\n");
  585.     localMailServer = null;
  586.   }
  587.  
  588.   try {
  589.  
  590.     if (!localMailServer) 
  591.     {
  592.       // dump("Creating local mail account\n");
  593.       // creates a copy of the identity you pass in
  594.       messengerMigrator = Components.classes["@mozilla.org/messenger/migrator;1"].getService(Components.interfaces.nsIMessengerMigrator);
  595.       messengerMigrator.createLocalMailAccount(false /* false, since we are not migrating */);
  596.       try {
  597.         localMailServer = am.localFoldersServer;
  598.       }
  599.       catch (ex) {
  600.         dump("error!  we should have found the local mail server after we created it.\n");
  601.         localMailServer = null;
  602.       }    
  603.     }
  604.   }
  605.   catch (ex) {dump("Error in verifyLocalFoldersAccount" + ex + "\n");  }
  606.  
  607. }
  608.  
  609. function setupCopiesAndFoldersServer(account, accountIsDeferred)
  610. {
  611.   try {
  612.     var server = account.incomingServer;
  613.     if (server.type == "rss")
  614.       return false;
  615.     var identity = account.identities.QueryElementAt(0, Components.interfaces.nsIMsgIdentity);
  616.     // For this server, do we default the folder prefs to this server, or to the "Local Folders" server
  617.     // If it's deferred, we use the local folders account.
  618.     var defaultCopiesAndFoldersPrefsToServer = !accountIsDeferred && server.defaultCopiesAndFoldersPrefsToServer;
  619.     dump ("verifying local folders account \n");
  620.  
  621.     var copiesAndFoldersServer = null;
  622.     if (defaultCopiesAndFoldersPrefsToServer) 
  623.     {
  624.       copiesAndFoldersServer = server;
  625.     }
  626.     else 
  627.     {
  628.       if (!am.localFoldersServer) 
  629.       {
  630.         dump("error!  we should have a local mail server at this point\n");
  631.         return;
  632.       }
  633.       copiesAndFoldersServer = am.localFoldersServer;
  634.     }
  635.       
  636.     setDefaultCopiesAndFoldersPrefs(identity, copiesAndFoldersServer);
  637.  
  638.   } catch (ex) {
  639.     // return false (meaning we did not setupCopiesAndFoldersServer)
  640.     // on any error
  641.     dump("Error setupCopiesAndFoldersServer" + ex + "\n");
  642.     return false;
  643.   }
  644.   return true;
  645. }
  646.  
  647. function setDefaultCopiesAndFoldersPrefs(identity, server)
  648. {
  649.     dump("finding folders on server = " + server.hostName + "\n");
  650.  
  651.     var rootFolder = server.rootFolder;
  652.  
  653.     // we need to do this or it is possible that the server's draft,
  654.     // stationery fcc folder will not be in rdf
  655.     //
  656.     // this can happen in a couple cases
  657.     // 1) the first account we create, creates the local mail.  since
  658.     // local mail was just created, it obviously hasn't been opened,
  659.     // or in rdf..
  660.     // 2) the account we created is of a type where
  661.     // defaultCopiesAndFoldersPrefsToServer is true
  662.     // this since we are creating the server, it obviously hasn't been
  663.     // opened, or in rdf.
  664.     //
  665.     // this makes the assumption that the server's draft, stationery fcc folder
  666.     // are at the top level (ie subfolders of the root folder.)  this works
  667.     // because we happen to be doing things that way, and if the user changes
  668.     // that, it will work because to change the folder, it must be in rdf,
  669.     // coming from the folder cache, in the worst case.
  670.     var folders = rootFolder.GetSubFolders();
  671.     var msgFolder = rootFolder.QueryInterface(Components.interfaces.nsIMsgFolder);
  672.     var numFolders = new Object();
  673.  
  674.     var protocolInfo = Components.classes["@mozilla.org/messenger/protocol/info;1?type=" + msgFolder.server.type].getService(Components.interfaces.nsIMsgProtocolInfo);
  675.  
  676.     /** 
  677.      * Check if this protocol service needs to create special folder URIs.
  678.      * In case of IMAP, when a new account is created, folders 'Sent', 'Drafts'
  679.      * and 'Templates' are not created then, but created on demand at runtime. 
  680.      * But we do need to present them as possible choices in the Copies and Folders 
  681.      * UI. To do that, folder URIs have to be created and stored in the prefs file. 
  682.      * So, if there is a need to build special folders, append the special folder 
  683.      * names and create right URIs.
  684.      */
  685.     if (protocolInfo.needToBuildSpecialFolderURIs)
  686.     {
  687.         var folderDelim = "/";
  688.  
  689.         /* we use internal names known to everyone like Sent, Templates and Drafts */
  690.  
  691.         identity.draftFolder = msgFolder.server.serverURI+ folderDelim + "Drafts";
  692.         identity.stationeryFolder = msgFolder.server.serverURI+ folderDelim + "Templates";
  693.         identity.fccFolder = msgFolder.server.serverURI+ folderDelim + "Sent";
  694.     }
  695.     else {
  696.         // these hex values come from nsMsgFolderFlags.h
  697.     var draftFolder = msgFolder.getFoldersWithFlag(0x0400, 1, numFolders);
  698.     var stationeryFolder = msgFolder.getFoldersWithFlag(0x400000, 1, numFolders);
  699.     var fccFolder = msgFolder.getFoldersWithFlag(0x0200, 1, numFolders);
  700.  
  701.     if (draftFolder) identity.draftFolder = draftFolder.URI;
  702.     if (stationeryFolder) identity.stationeryFolder = stationeryFolder.URI;
  703.     if (fccFolder) identity.fccFolder = fccFolder.URI;
  704.  
  705.     dump("fccFolder = " + identity.fccFolder + "\n");
  706.     dump("draftFolder = " + identity.draftFolder + "\n");
  707.     dump("stationeryFolder = " + identity.stationeryFolder + "\n");
  708.     }
  709.     
  710.     identity.fccFolderPickerMode = gDefaultSpecialFolderPickerMode;
  711.     identity.draftsFolderPickerMode = gDefaultSpecialFolderPickerMode;
  712.     identity.tmplFolderPickerMode = gDefaultSpecialFolderPickerMode;
  713. }
  714.  
  715. function AccountExists(userName,hostName,serverType)
  716. {
  717.   var accountExists = false;
  718.   var accountManager = Components.classes["@mozilla.org/messenger/account-manager;1"].getService(Components.interfaces.nsIMsgAccountManager);
  719.   try {
  720.         var server = accountManager.findRealServer(userName,hostName,serverType,0);
  721.         if (server) {
  722.                 accountExists = true;
  723.         }
  724.   }
  725.   catch (ex) {
  726.         accountExists = false;
  727.   }
  728.   return accountExists;
  729. }
  730.  
  731. function getFirstInvalidAccount()
  732. {
  733.     am = Components.classes["@mozilla.org/messenger/account-manager;1"].getService(Components.interfaces.nsIMsgAccountManager);
  734.  
  735.     var invalidAccounts = getInvalidAccounts(am.accounts);
  736.   
  737.     if (invalidAccounts.length > 0)
  738.         return invalidAccounts[0];
  739.     else
  740.         return null;
  741. }
  742.  
  743. function checkForInvalidAccounts()
  744. {
  745.     var firstInvalidAccount = getFirstInvalidAccount();
  746.  
  747.     if (firstInvalidAccount) {
  748.         var pageData = GetPageData();
  749.         dump("We have an invalid account, " + firstInvalidAccount + ", let's use that!\n");
  750.         gCurrentAccount = firstInvalidAccount;
  751.  
  752.         // there's a possibility that the invalid account has ISP defaults
  753.         // as well.. so first pre-fill accountData with ISP info, then
  754.         // overwrite it with the account data
  755.  
  756.  
  757.         var identity =
  758.             firstInvalidAccount.identities.QueryElementAt(0, nsIMsgIdentity);
  759.  
  760.         var accountData = null;
  761.         // If there is a email address already provided, try to get to other ISP defaults.
  762.         // If not, get pre-configured data, if any.
  763.         if (identity.email) {
  764.           dump("Invalid account: trying to get ISP data for " + identity.email + "\n");
  765.           accountData = getIspDefaultsForEmail(identity.email);
  766.           dump("Invalid account: Got " + accountData + "\n");
  767.  
  768.           // account -> accountData -> pageData
  769.           accountData = AccountToAccountData(firstInvalidAccount, accountData);
  770.         }
  771.         else {
  772.           accountData = getPreConfigDataForAccount(firstInvalidAccount);
  773.         }
  774.         
  775.         AccountDataToPageData(accountData, pageData);
  776.  
  777.         gCurrentAccountData = accountData;
  778.  
  779.         setupWizardPanels();
  780.         // Set the page index to identity page.
  781.         document.documentElement.pageIndex = 1;
  782.     }
  783. }
  784.  
  785. // Transfer all invalid account information to AccountData. Also, get those special 
  786. // preferences (not associated with any interfaces but preconfigurable via prefs or rdf files) 
  787. // like whether not the smtp server associated with this account requires 
  788. // a user name (mail.identity.<id_key>.smtpRequiresUsername) and the choice of skipping 
  789. // panels (mail.identity.<id_key>.wizardSkipPanels).
  790. function getPreConfigDataForAccount(account)
  791. {
  792.   var accountData = new Object;
  793.   accountData = new Object;
  794.   accountData.incomingServer = new Object;
  795.   accountData.identity = new Object;
  796.   accountData.smtp = new Object;
  797.  
  798.   accountData = AccountToAccountData(account, null);
  799.  
  800.   var identity = account.identities.QueryElementAt(0, nsIMsgIdentity);
  801.  
  802.   try {
  803.     var skipPanelsPrefStr = "mail.identity." + identity.key + ".wizardSkipPanels";
  804.     accountData.wizardSkipPanels = gPrefs.getCharPref(skipPanelsPrefStr);
  805.  
  806.     if (identity.smtpServerKey) {
  807.       var smtpServer = smtpService.getServerByKey(identity.smtpServerKey);
  808.       accountData.smtp = smtpServer;
  809.  
  810.       var smtpRequiresUsername = false;
  811.       var smtpRequiresPrefStr = "mail.identity." + identity.key + ".smtpRequiresUsername";
  812.       smtpRequiresUsername = gPrefs.getBoolPref(smtpRequiresPrefStr);
  813.       accountData.smtpRequiresUsername = smtpRequiresUsername;
  814.     }
  815.   }
  816.   catch(ex) {
  817.     // reached here as special identity pre-configuration prefs 
  818.     // (wizardSkipPanels, smtpRequiresUsername) are not defined.
  819.   }
  820.  
  821.   return accountData;
  822. }
  823.  
  824. function AccountToAccountData(account, defaultAccountData)
  825. {
  826.     dump("AccountToAccountData(" + account + ", " +
  827.          defaultAccountData + ")\n");
  828.     var accountData = defaultAccountData;
  829.     if (!accountData)
  830.         accountData = new Object;
  831.     
  832.     accountData.incomingServer = account.incomingServer;
  833.     accountData.identity = account.identities.QueryElementAt(0, nsIMsgIdentity);
  834.     accountData.smtp = smtpService.defaultServer;
  835.  
  836.     return accountData;
  837. }
  838.  
  839. // sets the page data, automatically creating the arrays as necessary
  840. function setPageData(pageData, tag, slot, value) {
  841.     if (!pageData[tag]) pageData[tag] = [];
  842.  
  843.     if (value == undefined) {
  844.         // clear out this slot
  845.         if (pageData[tag][slot]) delete pageData[tag][slot];
  846.     } else {
  847.         // pre-fill this slot
  848.         if (!pageData[tag][slot]) pageData[tag][slot] = [];
  849.         pageData[tag][slot].id = slot;
  850.         pageData[tag][slot].value = value;
  851.     }
  852. }
  853.  
  854. // value of checkbox on the first page
  855. function serverIsNntp(pageData) {
  856.   if (pageData.accounttype.newsaccount)
  857.     return pageData.accounttype.newsaccount.value;
  858.   return false;
  859. }
  860.  
  861. function getUsernameFromEmail(email)
  862. {
  863.     var emailData = email.split("@");
  864.     return emailData[0];
  865. }
  866.  
  867. function getCurrentUserName(pageData)
  868. {
  869.     var userName = "";
  870.  
  871.     if (pageData.login) {
  872.         if (pageData.login.username) {
  873.             userName = pageData.login.username.value;
  874.         }
  875.     }
  876.     if (userName == "") {
  877.         var email = pageData.identity.email.value;
  878.         userName = getUsernameFromEmail(email); 
  879.     }
  880.     return userName;
  881. }
  882.  
  883. function getCurrentServerType(pageData) {
  884.     var servertype = "pop3";    // hopefully don't resort to default!
  885.     if (serverIsNntp(pageData))
  886.         servertype = "nntp";
  887.     else if (pageData.server && pageData.server.servertype)
  888.         servertype = pageData.server.servertype.value;
  889.     return servertype;
  890. }
  891.  
  892. function getCurrentServerIsDeferred(pageData) {
  893.     var serverDeferred = false; 
  894.     if (getCurrentServerType(pageData) == "pop3" && pageData.server && pageData.server.deferStorage)
  895.         serverDeferred = pageData.server.deferStorage.value;
  896.  
  897.     return serverDeferred;
  898. }
  899.  
  900. function getCurrentHostname(pageData) {
  901.     if (serverIsNntp(pageData))
  902.         return pageData.newsserver.hostname.value;
  903.     else
  904.         return pageData.server.hostname.value;
  905. }
  906.  
  907. function GetPageData()
  908. {
  909.     if (!gPageData)
  910.       gPageData = new Object;
  911.  
  912.     return gPageData;
  913. }
  914.  
  915. function PrefillAccountForIsp(ispName)
  916. {
  917.     dump("AccountWizard.prefillAccountForIsp(" + ispName + ")\n");
  918.  
  919.     var ispData = getIspDefaultsForUri(ispName);
  920.     
  921.     var pageData = GetPageData();
  922.  
  923.     if (!ispData) {
  924.       SetCurrentAccountData(null);
  925.       return;
  926.     }
  927.  
  928.     // prefill the rest of the wizard
  929.     dump("PrefillAccountForISP: filling with " + ispData + "\n");
  930.     SetCurrentAccountData(ispData);
  931.     AccountDataToPageData(ispData, pageData);
  932. }
  933.  
  934. // does any cleanup work for the the account data
  935. // - sets the username from the email address if it's not already set
  936. // - anything else?
  937. function FixupAccountDataForIsp(accountData)
  938. {
  939.     // no fixup for news
  940.     // setting the username does bad things
  941.     // see bugs #42105 and #154213
  942.     if (accountData.incomingServer.type == "nntp")
  943.       return;
  944.  
  945.     var email = accountData.identity.email;
  946.     var username;
  947.  
  948.     if (email) {
  949.       username = getUsernameFromEmail(email);
  950.     }
  951.     
  952.     // fix up the username
  953.     if (!accountData.incomingServer.username) {
  954.         accountData.incomingServer.username = username;
  955.     }
  956.  
  957.     if (!accountData.smtp.username &&
  958.         accountData.smtpRequiresUsername) {
  959.       // fix for bug #107953
  960.       // if incoming hostname is same as smtp hostname
  961.       // use the server username (instead of the email username)
  962.       if (accountData.smtp.hostname == accountData.incomingServer.hostName)
  963.         accountData.smtp.username = accountData.incomingServer.username;
  964.       else
  965.         accountData.smtp.username = username;
  966.     }
  967. }
  968.  
  969. function SetCurrentAccountData(accountData)
  970. {
  971.     //    dump("Setting current account data (" + gCurrentAccountData + ") to " + accountData + "\n");
  972.     gCurrentAccountData = accountData;
  973. }
  974.  
  975. function getInterfaceForType(type) {
  976.     try {
  977.         var protocolInfoContractIDPrefix = "@mozilla.org/messenger/protocol/info;1?type=";
  978.         
  979.         var thisContractID = protocolInfoContractIDPrefix + type;
  980.         
  981.         var protoInfo = Components.classes[thisContractID].getService(Components.interfaces.nsIMsgProtocolInfo);
  982.         
  983.         return protoInfo.serverIID;
  984.     } catch (ex) {
  985.         dump("could not get IID for " + type + ": " + ex + "\n");
  986.         return undefined;
  987.     }
  988. }
  989.  
  990. // flush the XUL cache - just for debugging purposes - not called
  991. function onFlush() {
  992.         gPrefs.setBoolPref("nglayout.debug.disable_xul_cache", true);
  993.         gPrefs.setBoolPref("nglayout.debug.disable_xul_cache", false);
  994.  
  995. }
  996.  
  997. /** If there are no default accounts..
  998.   * this is will be the new default, so enable
  999.   * check for mail at startup
  1000.   */
  1001. function EnableCheckMailAtStartUpIfNeeded(newAccount)
  1002. {
  1003.     // Check if default account exists and if that account is alllowed to be
  1004.     // a default account. If no such account, make this one as the default account 
  1005.     // and turn on the new mail check at startup for the current account   
  1006.     if (!(gDefaultAccount && gDefaultAccount.incomingServer.canBeDefaultServer)) { 
  1007.         am.defaultAccount = newAccount;
  1008.         newAccount.incomingServer.loginAtStartUp = true;
  1009.         newAccount.incomingServer.downloadOnBiff = true;
  1010.     }
  1011. }
  1012.  
  1013. function SetSmtpRequiresUsernameAttribute(accountData) 
  1014. {
  1015.     // If this is the default server, time to set the smtp user name
  1016.     // Set the generic attribute for requiring user name for smtp to true.
  1017.     // ISPs can override the pref via rdf files.
  1018.     if (!(gDefaultAccount && gDefaultAccount.incomingServer.canBeDefaultServer)) { 
  1019.         accountData.smtpRequiresUsername = true;
  1020.     }
  1021. }
  1022.  
  1023. function setNextPage(currentPageId, nextPageId) {
  1024.     var currentPage = document.getElementById(currentPageId);
  1025.     currentPage.next = nextPageId;
  1026. }
  1027.  
  1028.